/**
 * 缓存工具函数
 * @author Wu.Liang
 * @date 2025-01-21
 */

/**
 * 本地存储缓存管理
 */
export const localCache = {
  /**
   * 设置缓存
   * @param {string} key 缓存键
   * @param {*} value 缓存值
   * @param {number} expiry 过期时间（毫秒）
   */
  set(key, value, expiry = 0) {
    try {
      const item = {
        value,
        timestamp: Date.now(),
        expiry: expiry > 0 ? Date.now() + expiry : 0
      }
      uni.setStorageSync(key, JSON.stringify(item))
    } catch (error) {
      console.error('设置本地缓存失败:', error)
    }
  },
  
  /**
   * 获取缓存
   * @param {string} key 缓存键
   * @param {*} defaultValue 默认值
   * @returns {*}
   */
  get(key, defaultValue = null) {
    try {
      const itemStr = uni.getStorageSync(key)
      if (!itemStr) return defaultValue
      
      const item = JSON.parse(itemStr)
      
      // 检查是否过期
      if (item.expiry > 0 && Date.now() > item.expiry) {
        this.remove(key)
        return defaultValue
      }
      
      return item.value
    } catch (error) {
      console.error('获取本地缓存失败:', error)
      return defaultValue
    }
  },
  
  /**
   * 删除缓存
   * @param {string} key 缓存键
   */
  remove(key) {
    try {
      uni.removeStorageSync(key)
    } catch (error) {
      console.error('删除本地缓存失败:', error)
    }
  },
  
  /**
   * 清空所有缓存
   */
  clear() {
    try {
      uni.clearStorageSync()
    } catch (error) {
      console.error('清空本地缓存失败:', error)
    }
  },
  
  /**
   * 检查缓存是否存在
   * @param {string} key 缓存键
   * @returns {boolean}
   */
  has(key) {
    try {
      const itemStr = uni.getStorageSync(key)
      if (!itemStr) return false
      
      const item = JSON.parse(itemStr)
      
      // 检查是否过期
      if (item.expiry > 0 && Date.now() > item.expiry) {
        this.remove(key)
        return false
      }
      
      return true
    } catch (error) {
      return false
    }
  },
  
  /**
   * 获取缓存大小
   * @returns {number}
   */
  size() {
    try {
      const info = uni.getStorageInfoSync()
      return info.keys.length
    } catch (error) {
      return 0
    }
  }
}

/**
 * 会话存储缓存管理
 */
export const sessionCache = {
  /**
   * 设置缓存
   * @param {string} key 缓存键
   * @param {*} value 缓存值
   */
  set(key, value) {
    try {
      uni.setStorageSync(`session_${key}`, JSON.stringify(value))
    } catch (error) {
      console.error('设置会话缓存失败:', error)
    }
  },
  
  /**
   * 获取缓存
   * @param {string} key 缓存键
   * @param {*} defaultValue 默认值
   * @returns {*}
   */
  get(key, defaultValue = null) {
    try {
      const value = uni.getStorageSync(`session_${key}`)
      return value ? JSON.parse(value) : defaultValue
    } catch (error) {
      console.error('获取会话缓存失败:', error)
      return defaultValue
    }
  },
  
  /**
   * 删除缓存
   * @param {string} key 缓存键
   */
  remove(key) {
    try {
      uni.removeStorageSync(`session_${key}`)
    } catch (error) {
      console.error('删除会话缓存失败:', error)
    }
  },
  
  /**
   * 清空所有会话缓存
   */
  clear() {
    try {
      const info = uni.getStorageInfoSync()
      info.keys.forEach(key => {
        if (key.startsWith('session_')) {
          uni.removeStorageSync(key)
        }
      })
    } catch (error) {
      console.error('清空会话缓存失败:', error)
    }
  }
}

/**
 * 内存缓存管理
 */
class MemoryCache {
  constructor() {
    this.cache = new Map()
  }
  
  /**
   * 设置缓存
   * @param {string} key 缓存键
   * @param {*} value 缓存值
   * @param {number} expiry 过期时间（毫秒）
   */
  set(key, value, expiry = 0) {
    const item = {
      value,
      timestamp: Date.now(),
      expiry: expiry > 0 ? Date.now() + expiry : 0
    }
    this.cache.set(key, item)
  }
  
  /**
   * 获取缓存
   * @param {string} key 缓存键
   * @param {*} defaultValue 默认值
   * @returns {*}
   */
  get(key, defaultValue = null) {
    const item = this.cache.get(key)
    if (!item) return defaultValue
    
    // 检查是否过期
    if (item.expiry > 0 && Date.now() > item.expiry) {
      this.remove(key)
      return defaultValue
    }
    
    return item.value
  }
  
  /**
   * 删除缓存
   * @param {string} key 缓存键
   */
  remove(key) {
    this.cache.delete(key)
  }
  
  /**
   * 清空所有缓存
   */
  clear() {
    this.cache.clear()
  }
  
  /**
   * 检查缓存是否存在
   * @param {string} key 缓存键
   * @returns {boolean}
   */
  has(key) {
    const item = this.cache.get(key)
    if (!item) return false
    
    // 检查是否过期
    if (item.expiry > 0 && Date.now() > item.expiry) {
      this.remove(key)
      return false
    }
    
    return true
  }
  
  /**
   * 获取缓存大小
   * @returns {number}
   */
  size() {
    return this.cache.size
  }
  
  /**
   * 清理过期缓存
   */
  cleanup() {
    const now = Date.now()
    for (const [key, item] of this.cache.entries()) {
      if (item.expiry > 0 && now > item.expiry) {
        this.cache.delete(key)
      }
    }
  }
}

// 创建内存缓存实例
export const memoryCache = new MemoryCache()

/**
 * 通用缓存管理
 */
export const cache = {
  /**
   * 设置缓存
   * @param {string} key 缓存键
   * @param {*} value 缓存值
   * @param {object} options 选项
   * @param {string} options.type 缓存类型 (local, session, memory)
   * @param {number} options.expiry 过期时间（毫秒）
   */
  set(key, value, options = {}) {
    const { type = 'local', expiry = 0 } = options
    
    switch (type) {
      case 'local':
        localCache.set(key, value, expiry)
        break
      case 'session':
        sessionCache.set(key, value)
        break
      case 'memory':
        memoryCache.set(key, value, expiry)
        break
      default:
        localCache.set(key, value, expiry)
    }
  },
  
  /**
   * 获取缓存
   * @param {string} key 缓存键
   * @param {object} options 选项
   * @param {string} options.type 缓存类型
   * @param {*} options.defaultValue 默认值
   * @returns {*}
   */
  get(key, options = {}) {
    const { type = 'local', defaultValue = null } = options
    
    switch (type) {
      case 'local':
        return localCache.get(key, defaultValue)
      case 'session':
        return sessionCache.get(key, defaultValue)
      case 'memory':
        return memoryCache.get(key, defaultValue)
      default:
        return localCache.get(key, defaultValue)
    }
  },
  
  /**
   * 删除缓存
   * @param {string} key 缓存键
   * @param {string} type 缓存类型
   */
  remove(key, type = 'local') {
    switch (type) {
      case 'local':
        localCache.remove(key)
        break
      case 'session':
        sessionCache.remove(key)
        break
      case 'memory':
        memoryCache.remove(key)
        break
      default:
        localCache.remove(key)
    }
  },
  
  /**
   * 清空缓存
   * @param {string} type 缓存类型
   */
  clear(type = 'local') {
    switch (type) {
      case 'local':
        localCache.clear()
        break
      case 'session':
        sessionCache.clear()
        break
      case 'memory':
        memoryCache.clear()
        break
      case 'all':
        localCache.clear()
        sessionCache.clear()
        memoryCache.clear()
        break
      default:
        localCache.clear()
    }
  },
  
  /**
   * 检查缓存是否存在
   * @param {string} key 缓存键
   * @param {string} type 缓存类型
   * @returns {boolean}
   */
  has(key, type = 'local') {
    switch (type) {
      case 'local':
        return localCache.has(key)
      case 'session':
        return sessionCache.get(key) !== null
      case 'memory':
        return memoryCache.has(key)
      default:
        return localCache.has(key)
    }
  }
}

/**
 * 缓存键常量
 */
export const CACHE_KEYS = {
  // 用户相关
  USER_TOKEN: 'user_token',
  USER_INFO: 'user_info',
  USER_SETTINGS: 'user_settings',
  
  // 应用相关
  APP_CONFIG: 'app_config',
  APP_VERSION: 'app_version',
  
  // 数据相关
  COMMUNITY_LIST: 'community_list',
  BUILDING_LIST: 'building_list',
  UNIT_LIST: 'unit_list',
  
  // 缓存相关
  CACHE_VERSION: 'cache_version',
  CACHE_TIMESTAMP: 'cache_timestamp'
}

/**
 * 缓存配置
 */
export const CACHE_CONFIG = {
  // 默认过期时间（毫秒）
  DEFAULT_EXPIRY: 24 * 60 * 60 * 1000, // 24小时
  
  // 短期缓存（毫秒）
  SHORT_EXPIRY: 5 * 60 * 1000, // 5分钟
  
  // 中期缓存（毫秒）
  MEDIUM_EXPIRY: 60 * 60 * 1000, // 1小时
  
  // 长期缓存（毫秒）
  LONG_EXPIRY: 7 * 24 * 60 * 60 * 1000, // 7天
  
  // 永久缓存
  PERMANENT: 0
}

export default cache 